package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * @Author: charls
 * @Description:TODO
 * @Date: 2023/05/10/ 15:45
 * @Version: 1.0
 */

public class ThreadTest {

    public static ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main.....start.....");
        /**
         * 初始化线程的 4 种方式
         * 1）、继承 Thread
         * 2）、实现 Runnable 接口
         * 3）、实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常）
         * 4）、线程池
         *
         * 区别：
         *    1、2不能得到返回值，3可以获取返回值
         *    1、2、3都不能控制资源
         *    4可以控制资源，性能稳定
         */

        // 方式一：继承 Thread
        /*Thread01 thread01=new Thread01();
        thread01.start();// 启动线程*/


        // 方式二：实现 Runnable 接口
        /*Runable01 runable01=new Runable01();
        new Thread(runable01).start();*/


        // 方式三：实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常）
        /*FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();

        // 阻塞等待整个线程执行完成，获取返回结果
        Integer integer = futureTask.get();*/


        // 我们以后在业务代码里面，以上三种启动线程的方式都不用。【将所有的多线程异步任务都交给线程池执行】

        // 方式四：线程池:给线程池直接提交任务
        // 当前系统中线程池只有一两个，每个异步任务，提交给线程池让它自己去执行
        service.execute(new Runable01());

        // Executors.newCachedThreadPool(); //core是0，所有都可回收
        // Executors.newFixedThreadPool(); // 固定大小，core=max，都不可回收
        // Executors.newScheduledThreadPool(); // 定时任务的线程池
        // Executors.newSingleThreadExecutor(); // 单线程的线程池，后台从队列里面获取任务，挨个执行

        System.out.println("main.....end.....");
    }

    public static class Thread01 extends Thread{

        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果："+i);
        }
    }

    public static class Runable01 implements Runnable{

        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果："+i);
        }
    }

    public static class Callable01 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果："+i);
            return i;
        }
    }
}
